# 1、写函数,将传入的列表或元祖对象的奇数位索引对应的元素,
#
# def get_odd_elements(obj):
#     return obj[1::2]
# obj = [1,2,3,4]
# print(get_odd_elements(obj))
# 2、写函数,判断用户传入的对象(string,list,tuple)长度是否大于5
#
# def check_length(obj):
#     return len(obj) > 5
# obj = [1,2,3,4]
# print(check_length(obj))
# 3、写函数,计算传入的string中,数字,字母,空格以及其它内容的个数,并返回结果
#
# string = input("请输入一串字符串")
# listnum = []
# listlet = []
# listspa = []
# listort = []
# for i in string:
#     if i.isdigit():
#         listnum.append(i)
#     elif i.isalpha():
#         listlet.append(i)
#     elif i.isspace():
#         listspa.append(i)
#     else:
#         listort.append(i)
# print("数字的个数是",len(listnum))
# print("字母的个数是",len(listlet))
# print("空格的个数是",len(listspa))
# print("其他的个数是",len(listort))
# 4、写函数,接收两个数字参数,返回较大的那个数字
#
# def get_max(num1, num2):
#     return max(num1, num2)
# num1 = input("请输入第一个数")
# num2 = input("请输入其二个数")
# print(get_max(num1,num2))
# 5、编写一个函数cacluate, 可以接收任意多个数,返回的是一个元组.
# 元组的第一个值为所有参数的平均值, 第二个值是大于平均值的所有数.
#
# def calculate(*args):
#     avg = sum(args) / len(args)
#     above_avg = [num for num in args if num > avg]
#     return avg, above_avg
# a = calculate(3,4,5,6)
# print(a)
# 6、编写一个函数, 接收字符串参数, 返回一个元组,
# 元组的第一个值为大写字母的个数, 第二个值为小写字母个数.
#
# def count_letters(string):
#     upper_count = sum(1 for char in string if char.isupper())
#     lower_count = sum(1 for char in string if char.islower())
#     return upper_count, lower_count
# a = count_letters("AAAAAvvvvvvv")
# print(a)
# pass7、编写函数, 接收一个列表(包含30个1~100之间的随机整形数)
# 和一个整形数k, 返回一个新列表.
# 函数需求:
# 将列表下标k之前对应(不包含k)的元素逆序;
# 将下标k及之后的元素逆序;
#
# def reverse_list(lst, k):
#     new_lst = lst[:k][::-1] + lst[k:][::-1]
#     return new_lst
# lst 中文题都没看明白
# pass8、编写函数，从键盘输入参数x和n，计算并显示形如x+xx +xxx + xxxx + xxxxx+xxx…xxx+ 的表达式前n项的值
#
# def calculate_expression(x, n):
#     terms = [int(str(x) * i) for i in range(1, n + 1)]
#     total = sum(terms)
#     return total
# x = input("输入x")
# n = input("输入n")
# a = calculate_expression(x, n)
# print(a)
# pass9、写函数,函数接收的4个参数分别是:姓名,性别(默认为男),年龄,地址
#
# 用户通过input输入这4个内容(支持持续输入,Q或q退出),并传递给函数
#
# 函数接收到这些内容,将其追加到student_msg文件中
#
# 重点:复习文件操作
#
# def add_student_info(name, gender="男", age="", address=""):
#     with open('student_msg.txt', 'a') as file:
#         file.write(f"姓名: {name}, 性别: {gender}, 年龄: {age}, 地址: {address}\n")
# 10、写函数,接收n个数字,返回这些数字的和(动态传参)
#
# def calculate_sum(*args):
#     return sum(args)
# a = calculate_sum(1,2,3,4)
# print(a)
# pass11、在实参中传入多个可迭代对象(要有string,list,tuple,set,dict),将每个对象的每个元素都加到args或kwargs里
#
# def combine_elements(*args, **kwargs):
#     elements = []
#     for arg in args:
#         if isinstance(arg, (str, list, tuple, set)):
#             elements.extend(arg)
#         elif isinstance(arg, dict):
#             elements.extend(arg.values())
#
#     for value in kwargs.values():
#         if isinstance(value, (str, list, tuple, set)):
#             elements.extend(value)
#         elif isinstance(value, dict):
#             elements.extend(value.values())
#
#     return elements

# 12、写函数,把传过来的列表中的每一个元素都用"_"拼接,并返回
#
# def join_with_underscore(lst):
#     new_string = '_'.join(str(element) for element in lst)
#     return new_string
# lst = [1,2,3,4]
# print(join_with_underscore(lst))
# 13、写函数,传入一个数字,返回这个数的阶乘
# 重点:累乘
#
# 示例：1x2x3....
#
# def factorial(num):
#     result = 1
#     for i in range(1, num + 1):
#         result *= i
#     return result
# num = 3
# print(factorial(num))
# 14、写函数,返回一个扑克牌列表,里面有52项,每一项都是一个tuple
#
# def create_deck():
#     suits = ['♠', '♥', '♣', '♦']
#     ranks = ['A', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K']
#     deck = [(suit, rank) for suit in suits for rank in ranks]
#     return deck
# print(create_deck())
# 15、用代码写一个99乘法表
#
# def print_multiplication_table():
#     for i in range(1, 10):
#         for j in range(1, i + 1):
#             result = i * j
#             print(f"{j} x {i} = {result}", end="\t")
#         print()
# print(print_multiplication_table())
# 16、编写函数，求1+2+3+…N的和
#
# def calculate_sum(N):
#     return sum(range(1, N + 1))
# N = 4
# print(calculate_sum(N))
# 17、编写一个函数，求多个数中的最大值
#
# def get_max(*args):
#     return max(args)
# print(get_max(3,4,5,6,7))
# 18、编写一个函数，提取指定字符串中所有的字母，然后拼接在一起产生一个新的字符串
#
# def extract_letters(string):
#     new_string = ''.join(char for char in string if char.isalpha())
#     return new_string
# print(extract_letters("abc45sdd23e"))
# 19、 定义一个学生注册函数enroll()，打印学生姓名，性别，年龄，城市， 使用默认参数降低调用函数的复杂度
#
# def enroll(name, gender="男", age="", city=""):
#     print(f"姓名: {name}, 性别: {gender}, 年龄: {age}, 城市: {city}")
# print(enroll(name="xtc", gender="男", age="18", city="沈阳"))
# 20、编写一个函数，接受一个字符串作为参数，并返回其中所有单词的首字母的大写形式
#
# def capitalize_words(string):
#     words = string.split()
#     capitalized_words = [word.capitalize() for word in words]
#     return ' '.join(capitalized_words)
# print(capitalize_words("abcde"))
# 21、写一个函数，求多个数的平均值
#
# def calculate_average(*args):
#     return sum(args) / len(args)
# print(calculate_average(2,3,4,5,6,7))
# 22、写一个自己的len函数，统计指定序列中元素的个数
#
# def get_length(sequence):
#     count = sum(1 for _ in sequence)
#     return count
# print(get_length("rttuuu"))
# 23、找出传入的列表或元组的奇数位对应的元素，并返回一个新的列表
#
# def get_odd_elements(obj):
#     return obj[1::2]
# print(get_odd_elements([1,2,3,4,5]))
# 24、编写一个函数，接受一个字符串列表作为参数，并返回一个字符串，其中包含所有字符串首字母的大写形式
#
# def capitalize_words(string):
#     words = string.split()
#     capitalized_words = [word.capitalize() for word in words]
#     return ' '.join(capitalized_words)
# print(capitalize_words("abcde"))
# 25、定义函数，有一个形参，传入的是列表，数组大小不超过 100个，
# # 数组中的每个元素值不允许超过 100，但是可以等于100，
# # 如果列表大小超过了100个截取到第100个为止，要求返回的列表格式：
#
# # 删除所有重复元素，使得每个元素只出现一次
# # 按照数字的大小，由高到低排序返回
#
# def modify_list(lst):
#     unique_lst = list(set(lst))
#     sorted_lst = sorted(unique_lst, reverse=True)
#     return sorted_lst
# print(modify_list([1,1,1,3,3,4,4,5,6]))
# 26、定义函数 getLength，打印用户传入的容器类型和数据长度
#
# def get_length(data):
#     container_type = type(data).__name__
#     data_length = len(data)
#     print(f"容器类型: {container_type}")
#     print(f"数据长度: {data_length}")
# print(get_length("gggg"))
# 27、定义函数 generateNum( )
# # 返回从0~9的十个数字中随机取出4个不重复的数字组成一个字符串
#
# import random
#
# def generate_num():
#     num_list = random.sample(range(10), 4)
#     num_string = ''.join(str(num) for num in num_list)
#     return num_string
# print(generate_num())
# 28、定义函数 moreThan(num)，判断输入的数字是否大于1500
#
# def more_than(num):
#     return num > 1500
# print(more_than(6666))
# 29、定义函数，有两个形参，第一个形参到第二个形参的范围，所有平方数之和
#
# def calculate_sum(start, end):
#     sum_of_squares = sum(i ** 2 for i in range(start, end + 1))
#     return sum_of_squares
# print(calculate_sum(6,9))
# 示例：func_a(5,10)
# 5x5+6x6+7x7+8x8+9x9+10x10...
#
# 30、写函数，检查传入字典的每一个value长度，如果大于2，
# # 那么仅保留前两个长度的内容， 并将新内容返回给调用者
#
# def truncate_values(dictionary):
#     new_dictionary = {}
#     for key, value in dictionary.items():
#         if len(value) > 2:
#             new_dictionary[key] = value[:2]
#         else:
#             new_dictionary[key] = value
#     return new_dictionary
# print(truncate_values({"a":"666","b":"jjjj","c":"99999"}))
# 31、写函数，判断用户传入的对象（字符串、列表、元组）的元素是否为空
#
# def check_empty(obj):
#     if not obj:
#         return True
#     else:
#         return False
# print(check_empty(""))
# 32、编写自定义函数，完成一个简单的减法运算函数
#
# def subtract(a, b):
#     return a - b
# print(subtract(7,8))
# 33、编写自定义函数，可以输出自己的名字即可。
#
# def print_name():
#     print("My name is [范庆才]")
# print(print_name())
# 34、编写自定义函数：剪刀石头布
# 游戏开始，初始状态下用户和电脑都有 100 分，赢一局+10 分，输一局-10 分。
#

# 当用户为 0 分时，游戏结束，提示游戏结束，比赛输了
#
# 当用户为 200 分时，游戏结束，提示游戏结束，赢得比赛、每轮比赛都输出当前的分数
#
# 1 代表剪刀 2 代表石头 3 代表布
#
# import random
#
#
# def rock_paper_scissors():
#     user_score = 100
#     computer_score = 100
#
#     while user_score > 0 and user_score < 200:
#         user_choice = input("请输入你的选择（剪刀-1，石头-2，布-3）：")
#         computer_choice = random.randint(1, 3)
#
#         if user_choice == '1' and computer_choice == 2:
#             user_score -= 10
#         elif user_choice == '1' and computer_choice == 3:
#             user_score += 10
#         elif user_choice == '2' and computer_choice == 1:
#             user_score += 10
#         elif user_choice == '2' and computer_choice == 3:
#             user_score -= 10
#         elif user_choice == '3' and computer_choice == 1:
#             user_score -= 10
#         elif user_choice == '3' and computer_choice == 2:
#             user_score += 10
#
#         print(f"You chose: {user_choice}")
#         print(f"Computer chose: {computer_choice}")
#         print(f"Your score: {user_score}")
#
#     if user_score == 0:
#         print("游戏结束，比赛输了")
#     elif user_score == 200:
#         print("游戏结束，赢得比赛")
# print(rock_paper_scissors())
# 35、编写一个函数，接受一个字符串作为参数，并返回该字符串的逆序字符串
#
# def reverse_string(string):
#     return string[::-1]
# print(reverse_string("hhgkk"))
# 36、编写一个函数，接受一个数字列表作为参数，并返回其中所有偶数的列表
#
# def get_even_numbers(lst):
#     even_numbers = [num for num in lst if num % 2 == 0]
#     return even_numbers
# print(get_even_numbers([1,2,3,8]))
# 37、编写一个函数，接受一个字符串列表作为参数，并返回其中最长的字符串。
#
# def find_longest_string(lst):
#     longest_string = max(lst, key=len)
#     return longest_string
# print(find_longest_string(["hhh","jjhjk","ggggfddxcc"]))
# 38、编写一个函数，接受一个数字列表作为参数，并返回其中所有数字的平方的总和
#
# def calculate_square_sum(lst):
#     square_sum = sum(num ** 2 for num in lst)
#     return square_sum
# print(calculate_square_sum([3,2,4]))
# 39、编写一个函数，接受一个整数作为参数，并返回其阶乘
# def factorial(num):
#     result = 1
#     for i in range(1, num + 1):
#         result *= i
#     return result
# print(factorial(7))